[์๋ฐ ORM ํ์ค JPA ํ๋ก๊ทธ๋๋ฐ - ๊น์ํ]์ ์ฝ๊ณ ์ธ์ฉํ๊ณ ์ ๋ฆฌํ๋ POST์ ๋๋ค.
๐ซ SQL์ ์ง์ ๋ค๋ฃฐ ๋ ๋ฐ์ํ๋ ๋ฌธ์ ์
"๊ด๊ณํ ๋ฐ์ดํฐ๋ฒ ์ด์ค๋ ๊ฐ์ฅ ๋์ค์ ์ด๊ณ ์ ๋ขฐํ ๋งํ ์์ ํ ๋ฐ์ดํฐ ์ ์ฅ์์ด๋ค."
์๋ฐ๋ก ์์ฑํ ์ ํ๋ฆฌ์ผ์ด์ ์ JDBC API๋ฅผ ์ฌ์ฉํด์ SQL์ DB์ ์ ๋ฌํด์ผ ํ๋ค. SQL์ ์ด์ฉํด DB๋ก๋ถํฐ ๊ฒฐ๊ณผ๋ฅผ ๋ฐํ๋ฐ์ ์ ํ๋ฆฌ์ผ์ด์ ์์ ์๋ง๊ฒ ์ฌ์ฉํ๋ค.
โฐ ๋ฐ๋ณต, ๋ฐ๋ณต ๊ทธ๋ฆฌ๊ณ ๋ฐ๋ณต
SQL์ ์ง์ ๋ค๋ฃฐ ๋์ ๋ฌธ์ ์ ์ ์์๋ด์ผ ํ๋ค. ์ด๋ฅผ ์ํด ์๋ฐ์ ๊ด๊ณํ DB๋ฅผ ์ฌ์ฉํ ํ์ ๊ด๋ฆฌ ๊ธฐ๋ฅ์ ๊ฐ๋ฐํด๋ณธ๋ค.
๋จผ์ , ์ฌ์ฉํ ํ์(Member) ๊ฐ์ฒด์ด๋ค.
public class Member {
private String memberId;
private String name;
...
}
ํ์ ๊ฐ์ฒด๋ฅผ DB์ ๊ด๋ฆฌํ๊ธฐ ์ํ ํ์์ฉ DAO(Data Access Object)๋ฅผ ๋ง๋ ๋ค.
public class MemberDAO {
public Member find(String memberId) {
...
}
}
์ด์ ์ ๋ฉ์๋๋ฅผ ์ด์ฉํด ํ์ ์กฐํ ๊ธฐ๋ฅ์ ๊ฐ๋ฐํ๋๋ฐ, ์ผ๋ฐ์ ์ธ ์์๋ ๋ค์๊ณผ ๊ฐ๋ค.
-
ํ์ ์กฐํ์ฉ SQL์ ์์ฑํ๋ค.
SELECT MEMBER_ID, NAME FROM MEMBER M WHERE MEMBER_ID = ?
-
JDBC API๋ฅผ ์ฌ์ฉํด์ SQL์ ์คํํ๋ค.
ResultSet rs = stmt.executeQuery(sql);
- DB๋ก๋ถํฐ ๋ฐํ๋ฐ์ ์กฐํ ๊ฒฐ๊ณผ๋ฅผ
Member๊ฐ์ฒด๋ก ๋งคํํ๋ค.
String memberId = rs.getString("MEMBER_ID");
String name = rs.getString("NAME");
Member member = new Member();
member.setMemberId(memberId);
member.setName(name);
ํ์ ์กฐํ๋ ์์ฑํ๊ณ , ํ์ ๋ฑ๋ก ๊ธฐ๋ฅ์ ๋ค์๊ณผ ๊ฐ์ด ๊ตฌํํ ์ ์๋ค.
public class MemberDAO {
public Member find(String memberId) {
...
}
public void save(Member member) {
...
}
}
-
ํ์ ๋ฑ๋ก์ฉ SQL์ ์์ฑํ๋ค.
String sql = "INSERT INTO MEMBER(MEMBER_ID, NAME) VALUES(?, ?)";
- ํ์ ๊ฐ์ฒด์ ๊ฐ์ ๊บผ๋ด ๋ฑ๋ก SQL์ ์ ๋ฌํ๋ค.
pstmt.setString(1, member.getMemberId());
pstmt.setString(2, member.getName());
-
JDBC API๋ฅผ ์ฌ์ฉํด์ SQL์ ์คํํ๋ค.
pstmt.executeUpdate(sql);
๋ค์์ผ๋ก ํ์ํ ๊ธฐ๋ฅ์ ํ์ ์ ๋ณด๋ฅผ ์์ ํ๊ณ ์ญ์ ํ๋ ๊ธฐ๋ฅ์ผ ๊ฒ์ด๋ค. ์ด๋ํ SQL์ ์์ฑํ๊ณ JDBC API๋ฅผ ์ฌ์ฉํด ์ด๋ฅผ ์คํํ๋ ๋ฐฉ์์ผ๋ก ๋์ผํ ๊ฒ์ด๋ค.
ํ์ ๊ฐ์ฒด๋ฅผ DB๊ฐ ์๋ ์๋ฐ ์ปฌ๋ ์ ์ ๋ณด๊ดํ๋ค๋ฉด ์ด๋ป๊ฒ ๋ ๊น?
- ์ปฌ๋ ์ ์
list.add(member);ํ ์ค๋ก ๊ฐ์ฒด๋ฅผ ์ ์ฅํ ์ ์๋ค.
DB๋ ๊ฐ์ฒด ๊ตฌ์กฐ์๋ ๋ค๋ฅธ ๋ฐ์ดํฐ ์ค์ฌ์ ๊ตฌ์กฐ๋ฅผ ๊ฐ์ ธ ๊ฐ์ฒด๋ฅผ DB์ ์ง์ ์ ์ฅํ๊ฑฐ๋ ์กฐํํ ์ ์๋ค.
- ๋ฐ๋ผ์, ๊ฐ๋ฐ์๊ฐ ๊ฐ์ฒด์งํฅ ์ ํ๋ฆฌ์ผ์ด์ ๊ณผ DB ์ค๊ฐ์์ SQL๊ณผ JDBC API๋ฅผ ์ฌ์ฉํด ์ง์ ๋ณํํด์ค์ผ ํ๋ค.
-
์ฌ๊ธฐ์ ๋ฌธ์ ๊ฐ ๋ฐ์ํ๋ค.
- ์ด๋ฌํ CRUD๋ฅผ ์ํ ์ฝ๋ ์์ฑ์ ๋งค์ฐ ๋ฐ๋ณต์ ์ด๊ณ , ๊ท์ฐฎ์ ์์ ์ด๋ค.
โฐ SQL์ ์์กด์ ์ธ ๊ฐ๋ฐ
"ํ์์ ์ฐ๋ฝ์ฒ๋ฅผ ํจ๊ป ์ ์ฅํด๋ฌ๋ผ"๋ ์๋ก์ด ์๊ตฌ์ฌํญ์ด ์ถ๊ฐ๋๋ค๋ฉด ์์์ ๊ตฌํํ ํ์ ๊ฐ์ฒด, INSERT SQL, ํ์ ์กฐํ ์ฝ๋, ํ์ ์ ๋ณด ์์ ์ฝ๋๊ฐ ๋ชจ๋ ์์ ๋์ด์ผ ํ๋ค.
๋ฑ๋ก ์ฝ๋ ๋ณ๊ฒฝ
ํ์์ ์ฐ๋ฝ์ฒ๋ฅผ ์ถ๊ฐํ๊ธฐ ์ํด ํ์ ๊ฐ์ฒด์ tel field๋ฅผ ์ถ๊ฐํ๋ค.
public class Member {
private String memberId;
private String name;
private String tel;
...
}
๊ทธ๋ฆฌ๊ณ DB์ ์ ๋ฌํ ํ์ ๋ฑ๋ก SQL ๋ํ ์ฐ๋ฝ์ฒ๋ ํจ๊ป ๋ฑ๋กํ ์ ์๋๋ก ์์ ํ๊ณ , JDBC API๋ ์ด์ ๋ง๊ฒ ์์ ํ๋ค.
String sql = "INSERT INTO MEMBER(MEMBER_ID, NAME, TEL) VALUES(?, ?, ?)";
...
pstmt.setString(3, member.getTel());
์กฐํ ์ฝ๋ ๋ณ๊ฒฝ
ํ์ ์กฐํ ์ ์ฐ๋ฝ์ฒ ํ๋ ๋ํ ์กฐํ ๊ฒฐ๊ณผ๋ก ์ป์ ์ ์๋๋ก SQL์ ์์ ํ๊ณ , Member ๊ฐ์ฒด์ ์ถ๊ฐ ๋งคํํ๋ค.
String sql = "SELECT MEMBER_ID, NAME, TEL FROM MEMBER WHERE MEMBER_ID = ?";
...
String tel = rs.getString("TEL");
member.setTel(tel);
์์ ์ฝ๋ ๋ณ๊ฒฝ
ํ์ ์์ ์ ์ฐ๋ฝ์ฒ ์ ๋ณด๋ ํจ๊ป ์์ ๋ ์ ์๋๋ก UPDATE SQL๊ณผ MemberDAO.update() ์ผ๋ถ๋ฅผ ์์ ํ๋ค.
ํ์ ๊ฐ์ฒด๋ฅผ ์๋ฐ ์ปฌ๋ ์ ์ ๋ณด๊ดํ๋ค๋ฉด, ํ๋๊ฐ ์ถ๊ฐ๋์ด๋ ๋ง์ ์ฝ๋์ ์์ ์ ์๊ตฌํ์ง ์์ ๊ฒ์ด๋ค.
list.add(member); // ๋ฑ๋ก Member member = list.get(xxx); // ์กฐํ member.setTel("xxx"); // ์์
์ฐ๊ด๋ ๊ฐ์ฒด
"ํ์์ ์ด๋ค ํ ํ์ ํ์๋ก ์์๋์ด์ผ ํ๋ค"๋ ์๊ตฌ์ฌํญ์ด ์ถ๊ฐ๋๋ค๋ฉด Member ๊ฐ์ฒด์ Team team ํ๋๊ฐ ์ถ๊ฐ๋ ๊ฒ์ด๋ค.
- ์ด๋, ํ์ ์ ๋ณด์ ํจ๊ป ์ฐ๊ด๋ ํ ์ด๋ฆ๋ ์ถ๋ ฅํ ์ ์๋๋ก ๊ธฐ๋ฅ์ ์ถ๊ฐํ๋ค.
class Team {
...
private String teamName;
...
}
์์ ํ: member.getTeam().getTeamName();
ํ์๊ณผ ์ฐ๊ด๋ ํ์ ์ ๋ณด๋ฅผ ์ถ๋ ฅํ๊ธฐ ์ํด์๋ ๋ค์ SQL๋ก ํ์๊ณผ ์ฐ๊ด๋ ํ์ ํจ๊ป ์กฐํํด์ผ ํ๋ค.
String sql = "SELECT M.MEMBER_ID, M.NAME, M.TEL, T.TEAM_ID, T.TEAM_NAME FROM MEMBER M JOIN TEAM T ON M.TEAM_ID = T.TEAM_ID";
SQL์ ๋ฌธ์ ์
Member๊ฐ์ฒด๊ฐ ์ฐ๊ด๋Team๊ฐ์ฒด๋ฅผ ์ฌ์ฉํ ์ ์์์ง ์์์ง๋ ์ ์ ์ผ๋ก ์ฌ์ฉํ๋ SQL์ ๋ฌ๋ ค ์๋ค. ํ์ง๋ง ์ด๋ฐ ๋ฐฉ์์ ๊ฐ์ฅ ํฐ ๋ฌธ์ ์ ์ ๋ฐ์ดํฐ ์ ๊ทผ ๊ณ์ธต์ ์ฌ์ฉํด์ SQL์ ์จ๊ฒจ๋, ์ด์ฉ ์ ์์ด DAO๋ฅผ ์ด์ด ์ด๋ค SQL์ด ์คํ๋๋์ง ํ์ธํด์ผ ํ๋ค๋ ์ ์ด๋ค.
๋ฌผ๋ฆฌ์ ์ผ๋ก SQL๊ณผ JDBC API๋ฅผ ๋ฐ์ดํฐ ์ ๊ทผ ๊ณ์ธต์ ์จ๊ธฐ๋๋ฐ๋ ์ฑ๊ณตํ์์ง ๋ชฐ๋ผ๋, ์ง๊ธ์ฒ๋ผ ๋ ผ๋ฆฌ์ ์ผ๋ก๋ ENTITY์ ์์ฃผ ๊ฐํ ์์กด๊ด๊ณ๋ฅผ ์ง๋๊ณ ์์ด ๊ฐ์ฒด์ ๋ํ ์๋ก์ด ์๊ตฌ์ฌํญ์ด ๋ฐ์ํ ๋๋ง๋ค ๋งค์ฐ ํฐ ๋ณด์ ๋น์ฉ์ด ๋ฐ์ํ๊ฒ ๋๋ค.
์ ํ๋ฆฌ์ผ์ด์ ์์ SQL์ ์ง์ ๋ค๋ฃฐ ๋ ๋ฐ์ํ๋ ๋ฌธ์ ์
- ์ง์ ํ ์๋ฏธ์ ๊ณ์ธต ๋ถํ ์ด ์ด๋ ต๋ค.
- ENTITY๋ฅผ ์ ๋ขฐํ ์ ์๋ค.
- SQL์ ์์กด์ ์ธ ๊ฐ๋ฐ์ ํผํ ์ ์๋ค.
โฐ JPA์ ๋ฌธ์ ํด๊ฒฐ
JPA๋ฅผ ์ฌ์ฉํ๋ฉด ๊ฐ์ฒด๋ฅผ DB์ ์ ์ฅํ๊ณ ๊ด๋ฆฌํ ๋, SQL์ ์์ฑํ๋ ๊ฒ์ด ์๋ JPA๊ฐ ์ ๊ณตํ๋ API๋ฅผ ์ฌ์ฉํ๋ฉด ๋๋ค. ๋ค์์ JPA๊ฐ ์ ๊ณตํ๋ CRUD API๋ค์ด๋ค.
์ ์ฅ ๊ธฐ๋ฅ
jpa.persist(member);
persist()๋ ๊ฐ์ฒด๋ฅผ DB์ ์ ์ฅํ๋ค.- JPA๊ฐ ๊ฐ์ฒด์ ๋งคํ์ ๋ณด๋ฅผ ๋ณด๊ณ ์ ์ ํ INSERT SQL์ ์์ฑํด DB๋ก ์ ๋ฌํ๋ค.
์กฐํ ๊ธฐ๋ฅ
String memberId = "ID";
Member member = jpa.find(Member.class, memberId);
find()๋ ๊ฐ์ฒด ํ๋๋ฅผ DB์์ ์กฐํํ๋ค.- ์ด๋ํ ๊ฐ์ฒด์ ๋งคํ์ ๋ณด๋ฅผ ๋ณด๊ณ ์ ์ ํ SELECT SQL์ ์์ฑํด DB๋ก ์ ๋ฌํ๊ณ , ๊ฒฐ๊ณผ๋ฅผ
Member๊ฐ์ฒด๋ฅผ ์์ฑํด ๋ฐํํ๋ค.
์์ ๊ธฐ๋ฅ
Member member = jpa.find(Member.class, memberId);
member.setName("๋ณ๊ฒฝ๋ ์ด๋ฆ");
- JPA๋ ๋ณ๋์ ์์ ๋ฉ์๋๋ฅผ ์ ๊ณตํ์ง ์๋๋ค.
- ๋์ ๊ฐ์ฒด๋ฅผ ์กฐํํด ๊ฐ์ ๋ณ๊ฒฝํ๋ฉด ํธ๋์ญ์ ์ ์ปค๋ฐํ ๋ DB์ ์ ์ ํ UPDATE SQL์ด ์ ๋ฌ๋๋ค.
์ฐ๊ด๋ ๊ฐ์ฒด ์กฐํ
Member member = jpa.find(Member.class, memberId);
Team team = member.getTeam();
-
JPA๋ ์ฐ๊ด๋ ๊ฐ์ฒด๋ฅผ ์ฌ์ฉํ๋ ์์ ์ ์ ์ ํ SELECT SQL์ ์คํํ๋ค.
- ๋ฐ๋ผ์ ์ฐ๊ด๋ ๊ฐ์ฒด๋ฅผ ๋ง์๊ป ์กฐํํ ์ ์๋ค.
๐ซ ํจ๋ฌ๋ค์์ ๋ถ์ผ์น
๊ฐ์ฒด์งํฅ ํ๋ก๊ทธ๋๋ฐ์ ์ถ์ํ, ์บก์ํ, ์ ๋ณด์๋, ์์, ๋คํ์ฑ ๋ฑ ์์คํ ์ ๋ณต์ก์ฑ์ ์ ์ดํ ์ ์๋ ๋ค์ํ ์ฅ์น๋ค์ ์ ๊ณตํ๋ค.
๋น์ฆ๋์ค ์๊ตฌ์ฌํญ์ ์ ์ํ ๋๋ฉ์ธ ๋ชจ๋ธ๋ ๊ฐ์ฒด๋ก ๋ชจ๋ธ๋งํ๋ฉด ๊ฐ์ฒด์งํฅ ์ธ์ด์ ์ฅ์ ๋ค์ ํ์ฉํ ์ ์๋ค.
- ๋ฌธ์ ๋ ์ด ๋๋ฉ์ธ ๋ชจ๋ธ์ ์ ์ฅํ ๋ ๋ฐ์ํ๋๋ฐ, ํน์ ์ ์ ๊ฐ ํ์๊ฐ์ ํ๋ฉด ํ์์ด๋ผ๋ ๊ฐ์ฒด๋ฅผ ์์ฑํ ํ ๋ฉ๋ชจ๋ฆฌ๊ฐ ์๋ ์ด๋๊ฐ์ ์๊ตฌ ์ ์ฅํด์ผ ํ๋ค.
๊ฐ์ฒด๋ ์์ฑ(ํ๋)๊ณผ ๊ธฐ๋ฅ(๋ฉ์๋)์ ๊ฐ์ง๋ค.
- ๊ธฐ๋ฅ์ ํด๋์ค์ ์ ์๋์ด ์์ด, ์ ์ฅ์์๋ ๊ฐ์ฒด์ ์ํ์ธ ์์ฑ๋ง์ ์ ์ฅํ๋ฉด ๋๋ค.
-
๊ฐ์ฒด๊ฐ ๋จ์ํ๋ฉด ์ด๋ ต์ง ์์ง๋ง, ๋ถ๋ชจ ๊ฐ์ฒด๋ฅผ ์์๋ฐ์๊ฑฐ๋, ๋ค๋ฅธ ๊ฐ์ฒด๋ฅผ ์ฐธ์กฐํ๊ณ ์๋ค๋ฉด ์ ์ฅ์ด ์ฝ์ง ์๋ค.
- ์๋ฅผ ๋ค์ด ํ์ ๊ฐ์ฒด๊ฐ ํ ๊ฐ์ฒด๋ฅผ ์ฐธ์กฐํ๊ณ ์๋ ๊ฒฝ์ฐ, ๋ ๊ฐ์ฒด๋ฅผ ํจ๊ป ์ ์ฅํด์ผ ํ๋ค.
์๋ฐ๋ ์ด๋ฐ ๋ฌธ์ ๋ฅผ ๊ณ ๋ คํด ๊ฐ์ฒด๋ฅผ ํ์ผ๋ก ์ ์ฅํ๋ ์ง๋ ฌํ ๊ธฐ๋ฅ๊ณผ ์ ์ฅ๋ ํ์ผ์ ๊ฐ์ฒด๋ก ๋ณต๊ตฌํ๋ ์ญ ์ง๋ ฌํ ๊ธฐ๋ฅ์ ์ง์ํ๋ค.
- ํ์ง๋ง ์ง๋ ฌํ๋ ๊ฐ์ฒด๋ฅผ ๊ฒ์ํ๊ธฐ ์ด๋ ค์ด ๋ฌธ์ ๊ฐ ์์ด ํ์ค์ฑ์ด ์๋ค.
- ํ์ค์ ์ธ ๋์์ ๊ด๊ณํ DB์ ๊ฐ์ฒด๋ฅผ ์ ์ฅํ๋ ๊ฒ์ธ๋ฐ, ๊ด๊ณํ DB๋ ๋ฐ์ดํฐ ์ค์ฌ์ผ๋ก ๊ตฌ์กฐํ๋์ด ์๊ณ , ์งํฉ์ ์ธ ์ฌ๊ณ ๋ฅผ ์๊ตฌํ๋ค. ๋ํ ์ถ์ํ, ์์, ๋คํ์ฑ ๊ฐ์ ๊ฐ๋ ์ด ์๋ค.
"๊ฐ์ฒด์ ๊ด๊ณํ DB๋ ์งํฅํ๋ ๋ชฉ์ ์ด ์๋ก ๋ฌ๋ผ ๊ธฐ๋ฅ๊ณผ ํํ ๋ฐฉ๋ฒ๋ ๋ค๋ฅด๋ค. ์ด๋ฅผ ๊ฐ์ฒด์ ๊ด๊ณํ DB์ ํจ๋ฌ๋ค์ ๋ถ์ผ์น ๋ฌธ์ ๋ผ๊ณ ํ๋ค. ๋ฐ๋ผ์ ๊ฐ์ฒด ๊ตฌ์กฐ๋ฅผ ํ ์ด๋ธ ๊ตฌ์กฐ์ ์ ์ฅํ๋ ๋ฐ๋ ๋น์ฐํ ํ๊ณ๊ฐ ์กด์ฌํ๋ค."
- ์ด๋ฌํ ํจ๋ฌ๋ค์ ๋ถ์ผ์น ๋ฌธ์ ๋ฅผ ํด๊ฒฐํ๊ธฐ ์ํด ์ค๊ฐ์ ์๋ ๊ฐ๋ฐ์๋ ๋๋ฌด ๋ง์ ์๊ฐ๊ณผ ์ฝ๋๋ฅผ ์๋นํ๋ค.
- ์๋๋ ์ด๋ก ์ธํด ๋ฐ์ํ๋ ๋ฌธ์ ๋ค์ ๊ตฌ์ฒด์ ์ผ๋ก ๋ค๋ฃฌ๋ค.
โฐ ์์
"๊ฐ์ฒด๋ ์์์ด๋ผ๋ ๊ธฐ๋ฅ์ ๊ฐ์ง๊ณ ์์ง๋ง, ํ ์ด๋ธ์ ๊ฐ์ง๊ณ ์์ง ์๋ค." (์ผ๋ถ DB๊ฐ ์ง์ํ๋ ์์ ๊ธฐ๋ฅ์ ๊ฐ์ฒด์ ์์๊ณผ๋ ๋ค๋ฅด๋ค.)
-
DB ๋ชจ๋ธ๋ง์์ ๋ค๋ฃจ๋ ์ํผํ์ ์๋ธํ์ ๊ด๊ณ๋ฅผ ์ฌ์ฉํ์ฌ ๊ฐ์ฒด ์์๊ณผ ์ ์ฌํ ํํ๋ก ํ ์ด๋ธ์ ์ค๊ณํ ์๋ ์๋ค.
- ํ ์ด๋ธ์ ํน์ ์ปฌ๋ผ์ ์ฌ์ฉํด์ ์ด๋ค ์์ ํ ์ด๋ธ๊ณผ ๊ด๊ณ๊ฐ ์๋์ง ์ ์ํ๋ ๋ฐฉ์
๊ฐ์ฒด ๋ชจ๋ธ ์ฝ๋๋ ๋ค์๊ณผ ๊ฐ๋ค.
abstract class Item {
Long id;
String name;
int price;
}
class Album extends Item {
String artist;
}
class Movie extends Item {
String director;
String actor;
}
class Book extends Item {
String author;
String isbn;
}
Album๊ฐ์ฒด๋ฅผ ์ ์ฅํ๊ธฐ ์ํด์๋ ๊ฐ์ฒด๋ฅผ ๋ถํดํด์ ๋ ๊ฐ์ SQL์ ์์ฑํด์ผ ํ๋ค. (ITEM,ALBUM)- JDBC API๋ฅผ ์ฌ์ฉํด ๋ถ๋ชจ ๊ฐ์ฒด์์ ๋ถ๋ชจ ๋ฐ์ดํฐ๋ง ๊บผ๋ด์
ITEM์ฉ INSERT SQL์ ์์ฑํ๊ณ , ์์ ๊ฐ์ฒด์์ ์์ ๋ฐ์ดํฐ๋ง ๊บผ๋ด์ALBUM์ฉ INSERT SQL์ ์์ฑํ๋ ๊ฒ์ ๋งค์ฐ ๋นํจ์จ์ ์ด๋ค. - ์กฐํํ๋ ๊ฒ ๋ํ ๋ ํ ์ด๋ธ์ ์กฐ์ธํ๊ณ , ๊ฒฐ๊ณผ๋ฅผ ๊ฐ์ฒด๋ก ๋งคํํ๋ ์์ ์ด ํ์ํ๋ค.
๐จ ๋ชจ๋ ํจ๋ฌ๋ค์์ ๋ถ์ผ์น๋ฅผ ํด๊ฒฐํ๊ธฐ ์ํด ์๋ชจ๋๋ ๋น์ฉ์ด๋ค.
๋ง์ฝ ์๋ฐ ์ปฌ๋ ์ ์ ์ฌ์ฉํด ํด๋น ๊ฐ์ฒด๋ค์ ๋ณด๊ดํ๋ค๋ฉด ๋ถ๋ชจ ์์ ๊ด๊ณ๋ ํ์ ์ ์๊ด์์ด ์๋์ ๊ฐ์ ์ฝ๋๋ก ๊ฐ๋ฅํ๋ค.
list.add(album); list.add(movie); Album album = list.get(albumId);
JPA์ ์์
JPA๋ ์์๊ณผ ๊ด๋ จ๋ ํจ๋ฌ๋ค์์ ๋ถ์ผ์น ๋ฌธ์ ๋ฅผ ๋ง์น ์๋ฐ ์ปฌ๋ ์ ์ ๊ฐ์ฒด๋ฅผ ์ ์ฅํ๋ฏ์ด JPA์๊ฒ ๊ฐ์ฒด๋ฅผ ์ ์ฅํ๊ฒ ํจ์ผ๋ก์จ ํด๊ฒฐํด์ค๋ค.
// Item์ ์์ํ Album๊ฐ์ฒด๋ฅผ ์ ์ฅํ๋ค.
jpa.persist(album);
- ์ด๋, JPA๋ ๋ SQL(
ITEMINSERT,ALBUMINSERT)์ ์คํํด ๊ฐ์ฒด๋ฅผ ๋ ํ ์ด๋ธ์ ๋๋ ์ ์ฅํ๋ค.
// Album ๊ฐ์ฒด๋ฅผ ์กฐํํ๋ค.
String albumId = "id100";
Album album = jpa.find(Album.class, albumId);
- JPA๋ ๋ ํ ์ด๋ธ์ ์กฐ์ธํด์ ํ์ํ ๊ฒฐ๊ณผ๋ฅผ ๊ฐ์ ธ์ ๋ฐํํ๋ค.
โฐ ์ฐ๊ด๊ด๊ณ
๊ฐ์ฒด๋ ์ฐธ์กฐ๋ฅผ ์ฌ์ฉํด ๋ค๋ฅธ ๊ฐ์ฒด์ ์ฐ๊ด๊ด๊ณ๋ฅผ ๊ฐ์ง๊ณ ์ด๋ฅผ ํตํด ์ฐ๊ด๋ ๊ฐ์ฒด๋ฅผ ์กฐํํ๋ ๋ฐ๋ฉด, ํ ์ด๋ธ์ ์ธ๋ ํค(Foreign Key)๋ฅผ ์ฌ์ฉํด ๋ค๋ฅธ ํ ์ด๋ธ๊ณผ ์ฐ๊ด๊ด๊ณ๋ฅผ ๊ฐ์ง๊ณ ์กฐ์ธ์ ์ฌ์ฉํด ์ฐ๊ด๋ ํ ์ด๋ธ์ ์กฐํํ๋ค.
- ์ด ๋ ๊ฐ์ ํจ๋ฌ๋ค์ ๋ถ์ผ์น๋ ๋งค์ฐ ๊ทน๋ณต์ด ์ด๋ ต๋ค.
Member ๊ฐ์ฒด๋ Member.team ํ๋์ Team ๊ฐ์ฒด์ ์ฐธ์กฐ๋ฅผ ๋ณด๊ดํด ์ฐ๊ด๊ด๊ณ๋ฅผ ๊ฐ์ง๋ค. ๋ฐ๋ผ์ member.getTeam() ์ผ๋ก ์ฐ๊ด๋ Team ์ ์กฐํํ ์ ์๋ค.
class Member {
Team team;
...
Team getTeam() {
return team;
}
}
class Team {
...
}
MEMBER ํ
์ด๋ธ์ MEMBER.TEAM_ID ์ธ๋ ํค ์ปฌ๋ผ์ ์ฌ์ฉํด TEAM ํ
์ด๋ธ๊ณผ ์ฐ๊ด๊ด๊ณ๋ฅผ ๊ฐ์ง๋ค. ์ด ํค๋ฅผ ์ฌ์ฉํด ํ
์ด๋ธ์ ์กฐ์ธํ์ฌ ์ฐ๊ด๋ TEAM ์ ์กฐํํ ์ ์๋ค.
SELECT M.*, T.* FROM MEMBER M JOIN TEAM T ON M.TEAM_ID = T.TEAM_ID
์ฌ๊ธฐ์, ๊ฐ์ฒด๋ ์ฐธ์กฐ๊ฐ ์๋ ๋ฐฉํฅ์ผ๋ก๋ง ์กฐํ๊ฐ ๊ฐ๋ฅํ๋ค. ์ฆ team.getMember() ๋ ๋ถ๊ฐ๋ฅํ๋ค. ํ์ง๋ง ํ
์ด๋ธ์ ์ธ๋ ํค ํ๋๋ก ์๋ฐฉํฅ์ผ๋ก ์กฐํ๊ฐ ๊ฐ๋ฅํ๋ค.
๊ฐ์ฒด๋ฅผ ํ ์ด๋ธ์ ๋ง์ถ์ด ๋ชจ๋ธ๋ง
๊ฐ์ฒด์ ํ ์ด๋ธ์ ์ฐจ์ด๋ฅผ ์์๋ณด๊ธฐ ์ํด ๊ฐ์ฒด๋ฅผ ๋จ์ํ ํ ์ด๋ธ์ ๋ง์ถฐ ๋ชจ๋ธ๋งํ๋ค.
class Member {
String id; // MEMBER_ID
Long teamId; // TEAM_ID
String userName; // USERNAME
}
class Team {
Long id; // TEAM_ID
String name; // NAME
}
- ์์ ๊ฐ์ด ๊ฐ์ฒด๋ฅผ ํ ์ด๋ธ์ ๋ง์ถฐ ๋ชจ๋ธ๋งํจ์ผ๋ก์จ ๊ฐ์ฒด๋ฅผ ํ ์ด๋ธ์ ์ ์ฅํ๊ฑฐ๋ ์กฐํํ๋ ๊ฒ์ ํธ๋ฆฌํด์ก๋ค.
-
ํ์ง๋ง ์ธ๋ ํค ๊ฐ์ ๊ทธ๋๋ก ๋ณด๊ดํ๋
teamIdํ๋๋ ๋ฌธ์ ๊ฐ ์๋ค.- ๊ด๊ณํ DB์ ๊ฒฝ์ฐ, "์กฐ์ธ" ๊ธฐ๋ฅ์ด ์์ด ์ธ๋ ํค ๊ฐ์ ๊ทธ๋๋ก ๋ณด๊ดํด๋ ์๊ด์์ง๋ง, ๊ฐ์ฒด๋ ์ฐ๊ด๋ ๊ฐ์ฒด์ ์ฐธ์กฐ๋ฅผ ๋ณด๊ดํด์ผ ์ฐธ์กฐ๋ฅผ ํตํด ์ฐ๊ด๋ ๊ฐ์ฒด๋ฅผ ์กฐํํ ์ ์๋ค.
์ธ๋ ํค๊น์ง ํ ์ด๋ธ์ ๋ง์ถ ๋ชจ๋ธ๋ง ๋ฐฉ์์ ์ฌ์ฉํ๊ฒ ๋๋ฉด
- ๊ฒฐ๊ตญ ์ฐธ์กฐ๋ฅผ ํตํด ์ฐ๊ด๋ ๊ฐ์ฒด๋ฅผ ์กฐํํ ์๊ฐ ์์ด์ง๊ณ ,
- ๊ฐ์ฒด์งํฅ์ ํน์ง์ ์์ด๋ฒ๋ฆฌ๊ฒ ๋๋ค.
๊ฐ์ฒด์งํฅ ๋ชจ๋ธ๋ง
์์์ ํ ์ด๋ธ์ ๋ง์ถ ๋ชจ๋ธ๋ง ๋ฐฉ์์ ๋ฌธ์ ์ (๊ฐ์ฒด์งํฅ์ ํน์ง์ ์์ค)์ ์ดํดํ๋ค. ์ด์ ์ฐธ์กฐ๋ฅผ ํตํ ์ฐ๊ด๊ด๊ณ๋ฅผ ๊ฐ์ง๋๋ก ๋ชจ๋ธ๋งํ๋ค.
class Member {
String id; // MEMBER_ID
Team team; // ์ฐธ์กฐ๋ก ์ฐ๊ด๊ด๊ณ๋ฅผ ๊ฐ์ง
String userName;
Team getTeam() {
return team;
}
}
class Team {
Long id; // TEAM_ID - PK
String name; // NAME
}
- ์ฐ๊ด๋
Team์ ์ฐธ์กฐ๋ฅผ ๋ณด๊ดํจ์ผ๋ก์จ,member.getTeam()์ผ๋ก ์ฐ๊ด๋ ๊ฐ์ฒด๋ฅผ ์กฐํํ ์ ์๋ค. -
ํ์ง๋ง ์ด๋ฐ ๊ฐ์ฒด์งํฅ ๋ชจ๋ธ๋ง์ ๊ฐ์ฒด๋ฅผ ํ ์ด๋ธ์ ์ ์ฅํ๊ฑฐ๋ ์กฐํํ๋ ๋ฐ์ ์ด๋ ค์์ด ์๋ค.
- ๊ฐ์ฒด์ ํ ์ด๋ธ์ ์ฐ๊ด๊ด๊ณ๋ฅผ ๋งบ๋ ๋ฐฉ์์ ์ฐจ์ด(ํ๋์ ์ธ๋ ํค)๋๋ฌธ์ธ๋ฐ, ์ด๋ ๊ฒฐ๊ตญ ๊ฐ๋ฐ์๊ฐ ์ค๊ฐ๋ค๋ฆฌ์ญํ ์ ์ํํด์ผ ํด๊ฒฐ์ด ๊ฐ๋ฅํ๋ค.
์ ์ฅ
- ๊ฐ์ฒด๋ฅผ DB์ ์ ์ฅํ๊ธฐ ์ํด
teamํ๋๋ฅผTEAM_ID์ธ๋ ํค ๊ฐ์ผ๋ก ๋ณํํ๋ค.
member.getId(); // MEMBER_ID - PK์ ์ ์ฅ
member.getTeam().getId(); // TEAM_ID - FK์ ์ ์ฅ, INSERT SQL์ ์ฌ์ฉ
member.getUserName(); // USERNAME ์ปฌ๋ผ์ ์ ์ฅ
์กฐํ
TEAM_ID์ธ๋ ํค ๊ฐ์Member๊ฐ์ฒด์team์ฐธ์กฐ๋ก ๋ณํํ๋ค.- ๋จผ์
MEMBER์TEAM์ ์กฐํํ๊ณ , ์ด ๊ฒฐ๊ณผ๋ก ๊ฐ์ฒด๋ฅผ ์์ฑํด ์ฐ๊ด๊ด๊ณ๋ฅผ ์ค์ ํ๊ณ ๋ฐํํ๋ค.
public Member find(String memberId) {
// SQL ์คํ
...
Member member = new Member();
...
// DB์์ ์กฐํํ ํ์ ๊ด๋ จ ์ ๋ณด๋ฅผ ๋ชจ๋ ์
๋ ฅ
Team team = new Team();
...
// DB์์ ์กฐํํ ํ ๊ด๋ จ ์ ๋ณด๋ฅผ ๋ชจ๋ ์
๋ ฅ
// ํ์๊ณผ ํ ๊ด๊ณ ์ค์
member.setTeam(team);
return member;
}
๋งค๋ฒ ์ธ๊ธํ๋ฏ, ์๋ฐ ์ปฌ๋ ์ ์ ์ ์ฅํ๋ค๋ฉด ์ด๋ฌํ ํจ๋ฌ๋ค์ ๋ถ์ผ์น ํด๊ฒฐ์ ์ํ ๋น์ฉ์ ์๋ชจ๋์ง ์๋๋ค.
JPA์ ์ฐ๊ด๊ด๊ณ
"JPA๋ ์ฐ๊ด๊ด๊ณ์ ๊ด๋ จ๋ ํจ๋ฌ๋ค์์ ๋ถ์ผ์น ๋ฌธ์ ๋ฅผ ํด๊ฒฐํด์ค๋ค."
member.setTeam(team); // ํ์๊ณผ ํ ๊ด๊ณ ์ค์
jpa.persist(member); // ํ์๊ณผ ์ฐ๊ด๊ด๊ณ ํจ๊ป ์ ์ฅ
- ๊ฐ๋ฐ์๋ ๊ทธ์ ๊ด๊ณ๋ฅผ ์ค์ ํ๊ณ ๊ฐ์ฒด๋ฅผ ์ ์ฅํ๊ธฐ๋ง ํ๋ฉด ๋๋ค.
- JPA๋ ์์์์ ์ค๊ฐ๋ค๋ฆฌ์ญํ ์ ์ํํด ์ ์ ํ SQL์ DB์ ์ ๋ฌํ๊ณ , ์ ์ ํ๊ฒ ๋ฐํํด์ค๋ค.
โฐ ๊ฐ์ฒด ๊ทธ๋ํ ํ์
๊ฐ์ฒด์์ ํ์์ด ์์๋ ํ ์กฐํ ์ ์ฐธ์กฐ๋ฅผ ์ฌ์ฉํ๋ ๊ฒ์ ๊ฐ์ฒด ๊ทธ๋ํ ํ์์ด๋ผ๊ณ ํ๋ค. ๊ฐ์ฒด ์ฐ๊ด๊ด๊ณ๊ฐ ์ฐ์์ ์ผ๋ก ์ด์ด์ ธ์๋ ๊ฒฝ์ฐ ์๋ ์ฝ๋์ ๊ฐ์ด ๋ง์๊ป ๊ฐ์ฒด ๊ทธ๋ํ๋ฅผ ํ์ํ ์ ์์ด์ผ ํ๋ค.
member.getOrder().getOrderItem();
ํ์ง๋ง DB๋ฅผ ์ฌ์ฉํ๋ ๊ฒฝ์ฐ, SELECT M.*, T.* FROM MEMBER M JOIN TEAM T ON M.TEAM_ID = T.TEAM_ID ๋ฅผ ์คํํด์ ํ์๊ณผ ํ์ ๋ํ ๋ฐ์ดํฐ๋ ์กฐํ๊ฐ ๊ฐ๋ฅํ์ง๋ง, ๋ค๋ฅธ ๊ฐ์ฒด ๊ทธ๋ํ๋ ๋ฐ์ดํฐ๊ฐ ์์ด ํ์ํ ์ ์๊ฒ ๋๋ค. (member.getOrder(); ์ ๊ฒฐ๊ณผ๋ null)
"SQL์ ์ง์ ๋ค๋ฃจ๋ฉด ์ฒ์ ์คํํ๋ SQL์ ๋ฐ๋ผ ๊ฐ์ฒด ๊ทธ๋ํ์ ํ์ ์์ญ์ด ์ ํ๋๋ค."
- ์ด๋ ๋น์ฆ๋์ค ๋ก์ง์ ๋ฐ๋ผ ์ฌ์ฉํ๋ ๊ฐ์ฒด ๊ทธ๋ํ๊ฐ ๋ค๋ฅธ๋ฐ ์ธ์ ๋์ด์ง์ง ๋ชจ๋ฅผ ๊ฐ์ฒด ๊ทธ๋ํ๋ฅผ ํจ๋ถ๋ก ํ์ํ ์๋ ์๊ธฐ์ ๊ฐ์ฒด์งํฅ ๊ฐ๋ฐ์์๊ฒ ๋งค์ฐ ํฐ ์ ์ฝ์ด๋ค.
class MemberService {
...
public void process() {
Member member = memberDAO.find(memberId);
member.getItem(); // member -> team ๊ฐ์ฒด ๊ทธ๋ํ ํ์์ด ๊ฐ๋ฅํ๊ฐ?
member.getOrder().getDelivery(); // ???
}
}
-
์ ์์ ๋
memberDAO๋ฅผ ํตํดmember๊ฐ์ฒด๋ฅผ ์กฐํํ์ง๋ง, ์ด ๊ฐ์ฒด์ ์ฐ๊ด๋ ๊ฐ์ฒด ๋ฐฉํฅ์ผ๋ก ๊ฐ์ฒด ๊ทธ๋ํ๋ฅผ ํ์ํ ์ ์์์ง๋ ์์ธกํ ์ ์๋ค.- ํ์ ๊ฐ๋ฅ ์ฌ๋ถ์ ํ์ธ์ ์ํด์๋
DAO์ SQL์ ์ง์ ํ์ธํ๋ ์๋ฐ์ ์๋ค. - ์ด๋ ์ด์ ์๋ ๋ค๋ฃฌ "ENTITY๊ฐ SQL์ ๋ ผ๋ฆฌ์ ์ผ๋ก ์ข ์"๋๊ธฐ์ ๋ฐ์ํ๋ ๋ฌธ์ ์ด๋ค.
- ๊ทธ๋ ๋ค๊ณ ์ฐ๊ด๋ ๋ชจ๋ ๊ฐ์ฒด ๊ทธ๋ํ๋ฅผ DB์์ ์กฐํํด์ ๋ฉ๋ชจ๋ฆฌ์ ์ฌ๋ ค๋๋ ๊ฒ์ ํ์ค์ฑ์ด ์๊ธฐ์
getMemberWithTeam(),getMemberWithOrderWithDelivery()์ ๊ฐ์ด ๊ฒฝ์ฐ์ ๋ฐ๋ฅธ ๋ฉ์๋๋ฅผ ์ฌ๋ฌ ๊ฐ ๋ง๋ค์ด ๋ฌ์ผ ํ๋ค.
- ํ์ ๊ฐ๋ฅ ์ฌ๋ถ์ ํ์ธ์ ์ํด์๋
JPA์ ๊ฐ์ฒด ๊ทธ๋ํ ํ์
JPA๋ฅผ ์ฌ์ฉํ๋ฉด ๊ฐ์ฒด ๊ทธ๋ํ๋ฅผ ๋ง์๊ป ํ์ํ ์ ์๋ค.
member.getOrder().getOrderItem();
์ด์ ์๋ ์ธ๊ธํ๋ฏ, JPA๋ ์ฐ๊ด๋ ๊ฐ์ฒด๋ฅผ ์ฌ์ฉํ๋ ์์ ์ ์ ์ ํ SQL์ ์คํํ๋ค.
- ์ฆ, ์ฐ๊ด๋ ๊ฐ์ฒด๋ฅผ ์ ๋ขฐํ๊ณ ๋ง์๊ป ์กฐํํ ์ ์๋ค.
- ์ด๋ ์ค์ ๊ฐ์ฒด๋ฅผ ์ฌ์ฉํ๋ ์์ ๊น์ง DB ์กฐํ๋ฅผ ๋ฏธ๋ฃฌ๋ค๊ณ ํ์ฌ "์ง์ฐ ๋ก๋ฉ"์ด๋ผ๊ณ ํ๋ค.
์ง์ฐ ๋ก๋ฉ
- JPA๋ ์ง์ฐ ๋ก๋ฉ์ ํฌ๋ช (transparent)ํ๊ฒ ์ฒ๋ฆฌํ๋ค. ์ฆ, JPA์ ๊ด๋ จ๋ ์ด๋ค ์ถ๊ฐ์ ์ธ ์ฝ๋๋ ํ์ํ์ง ์๋ค.
Member member = jpa.find(Member.class, memberId);
Order order = member.getOrder();
order.getOrderDate(); // Order๋ฅผ ์ฌ์ฉํ๋ ์์ ์ SELECT ORDER SQL
- ์ค์
Order๊ฐ์ฒด๋ฅผ ์ฌ์ฉํ๋ ์์ ์ JPA๋ DB์์ ํ ์ด๋ธ์ ์กฐํํ๊ฒ ๋๋ค.
โฐ ๋น๊ต
DB๋ ๊ธฐ๋ณธ ํค์ ๊ฐ์ผ๋ก ๊ฐ ํ์ ๊ตฌ๋ถํ๋ค. ํ์ง๋ง ๊ฐ์ฒด๋ ๋์ผ์ฑ ๋น๊ต์ ๋๋ฑ์ฑ ๋น๊ต๋ผ๋ ๋ ๊ฐ์ง ๋น๊ต ๋ฐฉ๋ฒ์ด ์๋ค.
- ๋์ผ์ฑ ๋น๊ต๋
==๋น๊ต์ด๋ค. ๊ฐ์ฒด ์ธ์คํด์ค์ ์ฃผ์ ๊ฐ์ ๋น๊ตํ๋ค. - ๋๋ฑ์ฑ ๋น๊ต๋
equals()๋ฉ์๋๋ฅผ ์ฌ์ฉํด์ ๊ฐ์ฒด ๋ด๋ถ์ ๊ฐ์ ๋น๊ตํ๋ค.
์ฌ๊ธฐ์ ํ๊ณ ์ถ์ ๋ง์, ํ ์ด๋ธ์ ํ์ ๊ตฌ๋ถํ๋ ๋ฐฉ๋ฒ๊ณผ ๊ฐ์ฒด๋ฅผ ๊ตฌ๋ถํ๋ ๋ฐฉ๋ฒ์๋ ์ฐจ์ด๊ฐ ์๋ค๋ ๊ฒ์ด๋ค.
class MemberDAO {
public Member getMember(String memberId) {
String sql = "SELECT * FROM MEMBER WHERE MEMBER_ID = ?";
...
// JDBC API, SQL ์คํ
return new Member(...);
}
}
String memberId = "100";
Member member1 = memberDAO.getMember(memberId);
Member member2 = memberDAO.getMember(memberId);
member1 == member2; // ๋ค๋ฅด๋ค!
-
๊ฐ์ ๊ธฐ๋ณธ ํค ๊ฐ์ผ๋ก ํ์ ๊ฐ์ฒด๋ฅผ ๋ ๋ฒ ์กฐํํ๋ค.
- ์กฐํํ ๊ฒฐ๊ณผ๋ฅผ ๋์ผ์ฑ ๋น๊ตํ๋ฉด,
false๊ฐ ๋ฐํ๋๋ค. - ์ด๋ ๊ฐ์ DB ํ์์ ์กฐํํ์ง๋ง, ๊ฐ์ฒด ์ธก๋ฉด์์ ๋ณผ ๋, ๋์ ์๋ก ๋ค๋ฅธ ์ธ์คํด์ค์ด๊ธฐ ๋๋ฌธ์ด๋ค. (
getMember()ํธ์ถ ์,new Member()๋ก ์ธ์คํด์ค๋ฅผ ๋งค๋ฒ ์๋ก ์์ฑ)
- ์กฐํํ ๊ฒฐ๊ณผ๋ฅผ ๋์ผ์ฑ ๋น๊ตํ๋ฉด,
- DB์ ๊ฐ์ ํ์ ์กฐํํ์ง๋ง ๋์ผ์ฑ ๋น๊ต๋ ์คํจํ๋ค. ํ์ง๋ง ์ด ๋ํ ์ปฌ๋ ์ ์ ๋ณด๊ดํ๋ค๋ฉด ๋์ผ์ฑ ๋น๊ต์ ์ฑ๊ณตํ์ ๊ฒ์ด๋ค.
์ด๋ฌํ ํจ๋ฌ๋ค์์ ๋ถ์ผ์น ๋ฌธ์ ๋ฅผ ํด๊ฒฐํ๊ธฐ ์ํด DB์ ๊ฐ์ ํ์ ์กฐํํ ๋๋ง๋ค ๊ฐ์ ์ธ์คํด์ค๋ฅผ ๋ฐํ๋๋๋ก ํ๋ ๊ฒ์ ์ฝ์ง ์๋ค. ๊ฑฐ๊ธฐ์ ํธ๋์ญ์ ๊น์ง ๊ณ ๋ คํ๋ค๋ฉด ๋ ๊ณจ์น๊ฐ ์ํ๋ค.
JPA์ ๋น๊ต
JPA๋ ๊ฐ์ ํธ๋์ญ์
์ผ ๋ ๊ฐ์ ๊ฐ์ฒด๊ฐ ์กฐํ๋๋ ๊ฒ์ ๋ณด์ฅํ๋ค. ๊ทธ๋ฌ๋ฏ๋ก ์ ์์ ์์ memberDAO.getMember() ๊ฐ ์๋ jpa.find() ๋ก ๋ ์ธ์คํด์ค์ ๋์ผ์ฑ ๋น๊ต๊ฐ ์ฑ๊ณตํ๋ค.
โฐ ์ ๋ฆฌ
JPA๋ ๊ฐ์ฒด ๋ชจ๋ธ๊ณผ ๊ด๊ณํ DB ๋ชจ๋ธ์ด ๊ฐ์ ์งํฅํ๋ ํจ๋ฌ๋ค์์ ๋ถ์ผ์น ๋ฌธ์ ๋ฅผ ํด๊ฒฐํด์ค์ผ๋ก์จ, ๊ฐ๋ฐ์๊ฐ ๋๋ฌด ๋ง์ ์๊ฐ๊ณผ ์ฝ๋๋ฅผ ์๋นํ์ง์๋๋ก ๋๋๋ค.
๐ซ JPA๋ ๋ฌด์์ผ๊น?
JPA(Java Persistence API)๋ ์๋ฐ ์ง์์ ORM ๊ธฐ์ ํ์ค์ด๋ค. ์ด๋ ์๋ฐ ์ ํ๋ฆฌ์ผ์ด์ ๊ณผ JDBC ์ฌ์ด์์ ๋์ํ๋ค.
๊ทธ๋ผ ORM์ ๋ฌด์์ผ๊น?
- Object Relational Mapping์ด๋ผ๋ ์ด๋ฆ ๊ทธ๋๋ก ๊ฐ์ฒด์ ๊ด๊ณํ DB๋ฅผ ๋งคํํ๋ค.
ORM ํ๋ ์์ํฌ๋ ๊ฐ์ฒด์ ํ ์ด๋ธ์ ๋งคํํด ํจ๋ฌ๋ค์์ ๋ถ์ผ์น ๋ฌธ์ ๋ฅผ ํด๊ฒฐํด์ค๋ค. ์ฆ INSERT SQL์ ์ง์ ์์ฑํ๋ ๊ฒ์ด ์๋ ๊ฐ์ฒด๋ฅผ ๋ง์น "์๋ฐ ์ปฌ๋ ์ ์ ์ ์ฅํ๋ฏ ORM ํ๋ ์์ํฌ์ ์ ์ฅ"ํ๋ฉด ๋๋ค.
MemberDAO ์์ Entity Object ๋ฅผ PERSIST(์ ์ฅ) ํ๋ฉด JPA๋,
- ํด๋น ENTITY๋ฅผ ๋ถ์ํ๊ณ
- INSERT SQL์ ์์ฑํ๊ณ
- JDBC API๋ฅผ ์ฌ์ฉํจ์ผ๋ก์จ
ํจ๋ฌ๋ค์์ ๋ถ์ผ์น ๋ฌธ์ ๋ฅผ ํด๊ฒฐํ๋ค.
FIND(์กฐํ)ํ ๋ ์ญ์
- SELECT SQL์ ์์ฑํ๊ณ
- JDBC API๋ฅผ ์ฌ์ฉํด
- ๋ฐํ๋ ๊ฒฐ๊ณผ๋ฅผ ResultSet์ ๋งคํํจ์ผ๋ก์จ
ํจ๋ฌ๋ค์์ ๋ถ์ผ์น ๋ฌธ์ ๋ฅผ ํด๊ฒฐํ๋ค.
์ด๋ ๋จ์ํ SQL์ ๊ฐ๋ฐ์ ๋์ ์์ฑํด DB์ ์ ๋ฌํ๋ ๊ฒ๋ฟ ์๋ ๋ค์ํ ํจ๋ฌ๋ค์์ ๋ถ์ผ์น ๋ฌธ์ ๋ค๋ ํด๊ฒฐํด์ค๋ค.
- ๋ฐ๋ผ์, ๊ฐ์ฒด ์ธก๋ฉด์์๋ ์ ๊ตํ ๊ฐ์ฒด ๋ชจ๋ธ๋ง์ด ๊ฐ๋ฅํด์ก๊ณ ,
- ๊ด๊ณํ DB๋ DB์ ๋ง๋๋ก ๋ชจ๋ธ๋ง์ ํ ์ ์๋ค.
- ๊ทธ๋ฆฌ๊ณ ๋งคํ ๋ฐฉ๋ฒ๋ง ORM ํ๋ ์์ํฌ์ ์ ๋ฌํ๋ฉด ๋๋ค.
๊ฐ์ฒด์งํฅ ์ธ์ด์ ๋ฐ๋ผ ๋ค์ํ ORM ํ๋ ์์ํฌ๋ค์ด ์กด์ฌํ๋ค. ๊ทธ์ค Hibernate ํ๋ ์์ํฌ๋ ๊ฑฐ์ ๋๋ถ๋ถ์ ํจ๋ฌ๋ค์ ๋ถ์ผ์น ๋ฌธ์ ๋ฅผ ํด์ฃผ๋ ํ๋ ์์ํฌ๋ก, ๊ฐ์ฅ ๋ง์ด ์ฌ์ฉ๋๋ค.
โฐ JPA ์๊ฐ
๊ณผ๊ฑฐ ์ํฐํ๋ผ์ด์ฆ ์๋ฐ ๋น์ฆ(EJB)๋ผ๋ ๊ธฐ์ ํ์ค์ด ์์๋ค. ๋ด๋ถ์๋ ์ํฐํฐ ๋น์ด๋ผ๋ ORM ๊ธฐ์ ๋ ํฌํจ๋์ด ์์๋๋ฐ, ๋๋ฌด ๋ณต์กํ๊ณ ๊ธฐ์ ์ฑ์๋๋ ๋จ์ด์ก์ผ๋ฉฐ ์๋ฐ ์ํฐํ๋ผ์ด์ฆ(J2EE) ์ ํ๋ฆฌ์ผ์ด์ ์๋ฒ์์๋ง ๋์ํ๋ค๋ ๋จ์ ์ด ์์๋ค.
์ด๋, Hibernate ์คํ์์ค ORM ํ๋ ์์ํฌ๊ฐ ๋ฑ์ฅํ๋ค. ์ด๋ ๋งค์ฐ ๊ฐ๋ณ๊ณ ์ค์ฉ์ ์ด๋ฉฐ ๊ธฐ์ ์ฑ์๋ ๋ํ ๋์ ์ด๋ฅผ ๊ธฐ๋ฐ์ผ๋ก ์๋ก์ด ์๋ฐ ORM ๊ธฐ์ ํ์ค์ ๋ง๋ค์๊ณ , ์ด๊ฒ์ด ๋ฐ๋ก JPA์ด๋ค.
JPA๋ ์๋ฐ ORM ๊ธฐ์ ์ ๋ํ API ํ์ค ๋ช ์ธ์ด๋ค.
-
์ธํฐํ์ด์ค๋ฅผ ๋ชจ์๋ ๊ฒ์ผ๋ก, JPA๋ฅผ ๊ตฌํํ ORM ํ๋ ์์ํฌ๋ฅผ ์ ํํด์ผ JPA๋ฅผ ์ฌ์ฉํ ์ ์๋ค.
- ํ์ฌ JPA 2.1์ ๊ตฌํํ ORM ํ๋ ์์ํฌ๋ Hibernate, EclipseLink, DataNucleus๊ฐ ์๋ค.
โฐ ์ JPA๋ฅผ ์ฌ์ฉํด์ผ ํ๋๊ฐ?
์ฌ๋ฌ๊ฐ์ง ์ด์ ๊ฐ ์๋ค. ํ๋์ฉ ์ดํด๋ณด๋๋ก ํ๋ค.
์์ฐ์ฑ
์์์ ์ฌ๋ฌ ๋ฒ ์ธ๊ธํ๋ฏ, ์๋ฐ ์ปฌ๋ ์ ์ ๊ฐ์ฒด๋ฅผ ์ ์ฅํ๋ ๊ฒ๊ณผ ๊ฐ์ ์ฝ๋ ๊ฐ๊ฒฐ์ฑ์ ์ป์ ์ ์๋ค. ์ง๋ฃจํ๊ณ ๋ฐ๋ณต์ ์ธ CRUD์ฉ SQL์ ๊ฐ๋ฐ์๊ฐ ์ง์ ์์ฑํ์ง ์์๋ ๋๊ณ , DDL๋ฌธ ๋ํ ์๋์ผ๋ก ์์ฑํด์ฃผ๊ธฐ๋ ํ๋ค.
DB ์ค๊ณ ์ค์ฌ์ ํจ๋ฌ๋ค์์ ๊ฐ์ฒด ์ค๊ณ ์ค์ฌ์ผ๋ก ์ญ์ ์ํฌ ์ ์๋ค.
์ ์ง๋ณด์
SQL์ ์ง์ ๋ค๋ฃจ๊ฒ ๋๋ฉด, ์ด์ ์๋ ์ธ๊ธํ๋ฏ ENTITY์ ํ๋๋ฅผ ํ๋๋ง ์ถ๊ฐํด๋ ๊ด๋ จ๋ SQL๊ณผ ๊ฒฐ๊ณผ๋ฅผ ๋งคํํ๊ธฐ ์ํ JDBC API ์ฝ๋๋ฅผ ๋ชจ๋ ์์ ํด์ผ ํ๋ค. ํ์ง๋ง JPA๋ ์ด๋ฐ ๋ชจ๋ ๊ณผ์ ์ ๋์ ์ฒ๋ฆฌํ๊ธฐ์ ๊ฒฐ๊ณผ์ ์ผ๋ก ์ ์ง๋ณด์ํด์ผํ๋ ์ฝ๋์ ์๊ฐ ์ค์ด๋๋ ์ด์ ์ ์ป์ ์ ์๋ค.
ํจ๋ฌ๋ค์์ ๋ถ์ผ์น ํด๊ฒฐ
JPA๋ ์ง๊ฒน๋๋ก ์ธ๊ธํ ์์, ์ฐ๊ด๊ด๊ณ, ๊ฐ์ฒด ๊ทธ๋ํ ํ์, ๋น๊ตํ๊ธฐ์ ๊ฐ์ ํจ๋ฌ๋ค์์ ๋ถ์ผ์น ๋ฌธ์ ๋ฅผ ํด๊ฒฐํด์ค๋ค.
์ฑ๋ฅ
์ ํ๋ฆฌ์ผ์ด์ ๊ณผ DB ์ฌ์ด์ ๊ณ์ธต์ด ํ๋ ๋ ์์ผ๋ฉด ์ต์ ํ ๊ด์ ์์ ์๋ํด ๋ณผ ์ ์๋ ๊ฒ๋ค์ด ๋ง๋ค. JPA๋ ์ด ์ค๊ฐ ๊ณ์ธต์ผ๋ก์, ๋ค์ํ ์ฑ๋ฅ ์ต์ ํ ๊ธฐํ๋ฅผ ์ ๊ณตํ๋ค.
String memberId = "helloId";
Member member1 = jpa.find(memberId);
Member member2 = jpa.find(memberId);
- ์ ์์๋ ๊ฐ์ ํธ๋์ญ์ ์์์ ๊ฐ์ ํ์์ ๋ ๋ฒ ์กฐํํ๋ ์ฝ๋์ธ๋ฐ, JDBC API๋ฅผ ์ฌ์ฉํ๋ค๋ฉด SELECT SQL์ ์ฌ์ฉํด DB์ ๋ ๋ฒ ํต์ ํ์ ๊ฒ์ด๋ค.
- ํ์ง๋ง JPA๋ฅผ ์ฌ์ฉํ๋ฉด, SELECT SQL์ ํ ๋ฒ๋ง DB์ ์ ๋ฌํ๊ณ , ๋๋ฒ์งธ ์กฐํ๋ ์ด๋ฏธ ์กฐํํ ํ์ ๊ฐ์ฒด๋ฅผ ์ฌ์ฌ์ฉํ์ฌ ์ต์ ํ๋ฅผ ์ ๊ณตํ ์ ์๋ค.
๋ฐ์ดํฐ ์ ๊ทผ ์ถ์ํ์ ๋ฒค๋ ๋ ๋ฆฝ์ฑ
๊ด๊ณํ DB๋ ๊ฐ์ ๊ธฐ๋ฅ์ด๋ผ๋ ๋ฒค๋๋ง๋ค ์ฌ์ฉ๋ฒ์ด ๋ค๋ฅธ ๊ฒฝ์ฐ๊ฐ ๋ง๋ค.
- ํ์ด์ง ์ฒ๋ฆฌ๋ DB๋ง๋ค ๋ฌ๋ผ์ ์ฌ์ฉ๋ฒ์ ๊ฐ๊ฐ ๋ฐฐ์์ผ ํ๋ค.
๊ฒฐ๊ตญ, ์ ํ๋ฆฌ์ผ์ด์ ์ ์ฒ์ ์ ํํ DB ๊ธฐ์ ์ ์ข ์๋๊ณ ๋ค๋ฅธ DB๋ก ๋ณ๊ฒฝ์ด ๋งค์ฐ ์ด๋ ค์์ง๋ค.
JPA๋ ์ ํ๋ฆฌ์ผ์ด์ ๊ณผ DB ์ฌ์ด์ ์ถ์ํ๋ ๋ฐ์ดํฐ ์ ๊ทผ ๊ณ์ธต์ ์ ๊ณตํด ํน์ DB ๊ธฐ์ ์ ์ข ์๋์ง ์๋๋ก ํ๋ค.
- DB๋ฅผ ๋ณ๊ฒฝํ๊ธฐ ์ํด์๋ JPA์๊ฒ ์ด๋ฅผ ์๋ ค์ฃผ๊ธฐ๋ง ํ๋ฉด ๋๋ค.
ํ์ค
JPA๋ ์๋ฐ ์ง์์ ORM ๊ธฐ์ ํ์ค์ผ๋ก์, ์ด๋ฅผ ์ฌ์ฉํ๋ฉด ๋ค๋ฅธ ๊ตฌํ ๊ธฐ์ ๋ก ์์ฝ๊ฒ ๋ณ๊ฒฝํ ์ ์๋ค.
"JPA๊ฐ ์ด๋ ค์ด ๊ทผ๋ณธ์ ์ธ ์ด์ ๋ ORM์ด ๊ฐ์ฒด์งํฅ๊ณผ ๊ด๊ณํ DB๋ผ๋ ๋ ๊ธฐ๋ฅ ์์ ์๊ธฐ ๋๋ฌธ์ ๋๋ค."
๐ ์ถ์ฒ
์๋ฐ ORM ํ์ค JPA ํ๋ก๊ทธ๋๋ฐ - ๊น์ํ